/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "ui插座编辑列表.h"

#include <字符串/str_分割.h>

#include <core/属性.h>
#include <节点/socket_utils.h>
#include <节点/逻辑/执行节点.h>
#include <节点/逻辑/单节点脚本.h>
#include <节点/网格/几何网格.h>
#include <节点/插座/几何插座.h>
#include <UI/ui绘制模板.h>

#include "A_引擎/引擎.h"
#include "框架/工作区/节点视口/ui节点面板.h"



static std::vector<S_MapPtrItem> g插座类型;
static C_编辑列表* g当前操作列表 = nullptr;

Inline int32 f_从类型取类型名称字符串(E_值类型 type) {
	int32 选中项 = -1;
	for (auto& e : S_节点数据::g_值类型名称映射) {
		++选中项;
		if (e.second == type) {
			return 选中项;
			break;
		}
	}
	return -1;
}


static std::vector<C_节点基类*> f_get子集输入输出节点(C_节点基类* node, E_插座方向 插座方向) {
	std::vector<C_节点基类*> Nodes;
	switch (node->m_Type) {
	case E_节点类型::e_节点Type_函数: {
		C_函数节点* 多边形节点 = static_cast<C_函数节点*>(node);
		if (插座方向 == E_插座方向::e_插座Type_输入) {
			多边形节点->f_get子集输入节点(Nodes);
		}
		else {
			多边形节点->f_get子集输出节点(Nodes);
		}
		break;
	}
	case E_节点类型::e_节点Type_几何: {
		C_几何节点* 多边形节点 = static_cast<C_几何节点*>(node);
		if (插座方向 == E_插座方向::e_插座Type_输入) {
			多边形节点->f_get子集输入节点(Nodes);
		}
		else {
			多边形节点->f_get子集输出节点(Nodes);
		}
		break;
	}
	case E_节点类型::e_节点Type_循环迭代: {
		C_循环迭代节点* loopNode = static_cast<C_循环迭代节点*>(node);
		if (插座方向 == E_插座方向::e_插座Type_输入) {
			loopNode->f_get子集输入节点(Nodes);
		}
		else {
			loopNode->f_get子集输出节点(Nodes);
		}
		break;
	}
	}

	return Nodes;
}

static void on_画插座编辑列表(C_Widget* self, S_2D画布* 画布) {
	C_编辑列表* box = static_cast<C_编辑列表*>(self);
	box->m_背景绘制.m_属性 = f_vg_gen属性(画布);

	S_凸边图元 图元 = {};
	图元.属性 = f_vg_get属性指针(画布, box->m_背景绘制.m_属性);
	box->m_背景绘制.f_Draw(画布, 图元, E_笔刷类型::e_单色填充);

}

static void on_插座编辑列表布局(C_Widget* self, C_Widget** w, uint32 num) {
	C_编辑列表* box = static_cast<C_编辑列表*>(self);

	float32 h = 24;
	float32 size = 28;
	
	auto& nodes = f_global_get激活节点();
	for (auto& node : nodes) {
		switch (node->m_Type) {
			case E_节点类型::e_节点Type_网格属性: {
				if (w[5]->m_开启渲染) {
					w[0]->f_setPos({ 2,2 });
					w[0]->f_setSize({ self->m_Size.x - h, self->m_Size.y - (size * 3) - 4 });

					w[5]->f_setPos({ 2, self->m_Size.y - (size * 3) });
					w[5]->f_setSize({ self->m_Size.x - 4, size - 6 });

				}
				else {
					w[0]->f_setPos({ 2,2 });
					w[0]->f_setSize({ self->m_Size.x - h, self->m_Size.y - 4 });
				}

				w[6]->f_setPos({ 2, self->m_Size.y - size * 2 });
				w[6]->f_setSize({ self->m_Size.x - 4, size - 6 });

				box->mui_属性分布方式->m_开启渲染 = true;
				box->mui_属性分布方式->f_setPos({ 2, self->m_Size.y - size });
				box->mui_属性分布方式->f_setSize({ self->m_Size.x - 4, size - 6 });
				break;
			}
			default: {
				if (w[5]->m_开启渲染) {
					w[0]->f_setPos({ 2,2 });
					w[0]->f_setSize({ self->m_Size.x - h, self->m_Size.y - (size * 2) - 4 });

					w[5]->f_setPos({ 2, self->m_Size.y - (size * 2) });
					w[5]->f_setSize({ self->m_Size.x - 4, size - 6 });

				}
				else {
					w[0]->f_setPos({ 2,2 });
					w[0]->f_setSize({ self->m_Size.x - h, self->m_Size.y - 4 });
				}

				if (box->mui_插座名称编辑框->m_开启渲染) {
					w[6]->f_setPos({ 2, self->m_Size.y - size });
					w[6]->f_setSize({ self->m_Size.x - 4, size - 6 });
				}
				if (box->mui_插座名称Vec编辑框->m_开启渲染) {
					w[6]->f_setPos({ 2, self->m_Size.y - 46 });
					w[6]->f_setSize({ self->m_Size.x - 4, 46 });
				}

				box->mui_属性分布方式->m_开启渲染 = false;
				break;
			}
				
		}
		break;
	}

	float32 pos = 22;
	//添加按钮
	w[1]->f_setX(self->m_Size.x - pos);
	//删除按钮
	w[2]->f_setPos({ self->m_Size.x - pos, h });
	//上移按钮
	w[3]->f_setPos({ self->m_Size.x - pos, h*2 });
	//下移按钮
	w[4]->f_setPos({ self->m_Size.x - pos, h*3 });

	

	return;
}

static void on_插座编辑列表属性修改(C_Widget* self) {
	C_编辑列表* box = static_cast<C_编辑列表*>(self);

	
}





static void on_插座编辑列表变换修改(C_Widget* self) {
	ui_绘制模板_预设图形& 背景绘制 = *static_cast<ui_绘制模板_预设图形*>(self->m_绘图模板[0]);
	ui_绘制模板_图标& 图标绘制 = *static_cast<ui_绘制模板_图标*>(self->m_绘图模板[1]);


	S_2D_PanelAttr 属性;
	属性.m_Scale = { 1,1 };
	属性.m_Offset = {};
	属性.m_间隔 = S_UI主题::ui_文字间隔;
	属性.m_渐变数量 = 0;
	f_vg_set属性(self->m_画布, 背景绘制.m_属性, 属性);



	背景绘制.f_alloc(4);

	mat3X2 mat;
	mat.row0 = {};
	mat.row1 = self->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(0, mat, S_UI主题::uic_浅灰, S_Widget预设凸包图元::m_圆角矩形);

	auto e = self->f_get更新组件();
	mat.row0 = e.m_W[0]->m_Pos;
	mat.row1 = e.m_W[0]->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(1, mat, e.m_W[0]->m_颜色A, S_Widget预设凸包图元::m_左圆角矩形);

	mat.row0 = e.m_W[2]->m_Pos;
	mat.row1 = e.m_W[2]->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(2, mat, e.m_W[2]->m_颜色A, S_Widget预设凸包图元::m_矩形);

	mat.row0 = e.m_W[3]->m_Pos;
	mat.row1 = e.m_W[3]->m_Size;
	mat.row2 = { S_UI主题::ui_面板圆角半径, 0 };
	背景绘制.f_set单色填充(3, mat, e.m_W[3]->m_颜色A, S_Widget预设凸包图元::m_右圆角矩形);




	图标绘制.f_alloc(3);
	mat.row0 = e.m_W[0]->m_Pos + e.m_W[0]->m_Size.y * 0.5;
	mat.row1.x = mat.row1.y = e.m_W[0]->m_Size.y * 0.8f;
	mat.row2 = {};
	图标绘制.f_set("import", 0, mat, S_UI主题::uic_深白);

	mat.row0 = e.m_W[2]->m_Pos + e.m_W[2]->m_Size.y * 0.5;
	mat.row1.x = mat.row1.y = e.m_W[2]->m_Size.y * 0.8f;
	mat.row2 = {};
	图标绘制.f_set("doc_plus", 1, mat, S_UI主题::uic_深白);

	mat.row0 = e.m_W[3]->m_Pos + e.m_W[3]->m_Size.y * 0.5;
	mat.row1.x = mat.row1.y = e.m_W[3]->m_Size.y * 0.8f;
	mat.row2 = {};
	图标绘制.f_set("delete", 2, mat, S_UI主题::uic_深白);

}



static void on_矢量编辑改变(C_Widget* self) {
	C_编辑列表* box = static_cast<C_编辑列表*>(self->m_父部件);
	int32 当前选项 = f_ui_列表框_取当前选中ID(box->m_ListBox);
	if (当前选项 >= 0) {
		//std::wstring text = f_ui_取行编辑框文本(self);

		auto& ContainerOut = f_prop_Container(box->m_Value);
		auto value_item = ContainerOut.m_Item[当前选项];

		auto& item = f_ui_列表框_取当前选中项(box->m_ListBox);
		item = f_构建数值列表填充项(value_item, 当前选项);
		box->m_ListBox->m_更新绘制属性 = true;
		//switch (box->m_Value.m_Type) {
		//	case E_值类型::e_Type_ContainerBool:
		//	case E_值类型::e_Type_ContainerF32: {
		//		f_prop_F32(value_item) = f_字符串转F32(text);
		//		break;
		//	}
		//
		//	case E_值类型::e_Type_ContainerI8:
		//	case E_值类型::e_Type_ContainerI32:
		//	case E_值类型::e_Type_ContainerUI32: {
		//		break;
		//	}
		//
		//	case E_值类型::e_Type_ContainerVec2: {
		//		f_prop_Vec2(value_item);
		//	}
		//	case E_值类型::e_Type_ContainerVec3:
		//	case E_值类型::e_Type_ContainerVec4:
		//	case E_值类型::e_Type_ContaineriVec2:
		//	case E_值类型::e_Type_ContaineriVec3:
		//	case E_值类型::e_Type_ContaineriVec4:
		//	case E_值类型::e_Type_ContainerBound:
		//	case E_值类型::e_Type_ContainerValue: {
		//		
		//
		//		
		//
		//		
		//		break;
		//	}
		//}

		auto& nodes = f_global_get激活节点();
		for (auto& node : nodes) {
			node->f_更新上层节点(true);
		}
	}
}


static void on_列表项改变_PropUpdate(S_Props& prop) {
	//g当前操作列表->m_ListBox;
	//g当前操作列表->m_ListBox;
	on_矢量编辑改变(g当前操作列表->mui_插座名称Vec编辑框);
	//prop.m_UI->m_部件->m_父部件;
}

S_列表填充数据 f_构建数值列表填充项(S_Props& 属性, int32 loc) {
	S_列表填充数据 填充项;

	属性.m_UI->m_Update = on_列表项改变_PropUpdate;

	switch (属性.m_Type) {
		case E_值类型::e_Type_F32: {
			填充项.m_item.push_back(f_浮点数值转宽字符串(f_prop_F32(属性)));
			break;
		}
		case E_值类型::e_Type_I8: {
			填充项.m_item.push_back(f_浮点数值转宽字符串(f_prop_I8(属性)));
			break;
		}
		case E_值类型::e_Type_I32: {
			填充项.m_item.push_back(f_浮点数值转宽字符串(f_prop_I32(属性)));
			break;
		}
		case E_值类型::e_Type_UI32: {
			填充项.m_item.push_back(f_浮点数值转宽字符串(f_prop_I32(属性)));
			break;
		}
		case E_值类型::e_Type_Vec2: {
			vec2 value = f_prop_Vec2(属性);
			填充项.m_item.push_back(f_浮点数值转宽字符串(value.x) + u" : " + f_浮点数值转宽字符串(value.y));
			break;
		}
		case E_值类型::e_Type_Vec3: {
			vec3 value = f_prop_Vec3(属性);
			填充项.m_item.push_back(f_浮点数值转宽字符串(value.x) + u" : " + f_浮点数值转宽字符串(value.y) + u" : " + f_浮点数值转宽字符串(value.z));
			break;
		}
		case E_值类型::e_Type_Vec4: {
			vec4 value = f_prop_Vec4(属性);
			填充项.m_item.push_back(f_浮点数值转宽字符串(value.x) + u" : " + f_浮点数值转宽字符串(value.y) + u" : " + f_浮点数值转宽字符串(value.z) + u" : " + f_浮点数值转宽字符串(value.w));
			break;
		}
		default:
			break;
	}

	填充项.m_itemID.push_back(loc);
	return 填充项;
}

//static S_列表填充数据 f_设置列表项文本(S_Props& 属性) {
//	S_列表填充数据 填充项;
//	switch (属性.m_Type) {
//		case E_值类型::e_Type_F32: {
//			填充项.m_item.push_back(f_浮点数值转宽字符串(f_prop_F32(属性)));
//			break;
//		}
//		case E_值类型::e_Type_I8: {
//			填充项.m_item.push_back(f_浮点数值转宽字符串(f_prop_I8(属性)));
//			break;
//		}
//		case E_值类型::e_Type_I32: {
//			填充项.m_item.push_back(f_浮点数值转宽字符串(f_prop_I32(属性)));
//			break;
//		}
//		case E_值类型::e_Type_UI32: {
//			填充项.m_item.push_back(f_浮点数值转宽字符串(f_prop_I32(属性)));
//			break;
//		}
//		case E_值类型::e_Type_Vec2: {
//			vec2 value = f_prop_Vec2(属性);
//			填充项.m_item.push_back(f_浮点数值转宽字符串(value.x) + u" : " + f_浮点数值转宽字符串(value.y));
//			break;
//		}
//		case E_值类型::e_Type_Vec3: {
//			vec3 value = f_prop_Vec3(属性);
//			填充项.m_item.push_back(f_浮点数值转宽字符串(value.x) + u" : " + f_浮点数值转宽字符串(value.y) + u" : " + f_浮点数值转宽字符串(value.z));
//			break;
//		}
//		case E_值类型::e_Type_Vec4: {
//			vec4 value = f_prop_Vec4(属性);
//			填充项.m_item.push_back(f_浮点数值转宽字符串(value.x) + u" : " + f_浮点数值转宽字符串(value.y) + u" : " + f_浮点数值转宽字符串(value.z) + u" : " + f_浮点数值转宽字符串(value.w));
//			break;
//		}
//		default:
//			break;
//	}
//	return 填充项;
//}

static void f_容器类别填充(C_Widget* 列表编辑框, S_Props& 容器, std::vector<S_列表填充数据>& items) {
	auto& ContainerOut = f_prop_Container(容器);
	uint32 num = ContainerOut.m_Item.size();
	for (uint32 i = 0; i < num; ++i) {
		auto value_item = ContainerOut.m_Item[i];
		S_列表填充数据 item = f_构建数值列表填充项(value_item, i);
		items.push_back(item);
	}

	if (num) {
		f_ui_绑定vec编辑框属性(列表编辑框, ContainerOut.m_Item.back());
	}
	
}

static void on_插座切换类型_项改变(S_Props& prop, S_MapPtr& ptrItem, int32 操作类型) {
	switch (prop.m_Type) {
		case E_值类型::e_Type_PropContainer: 
		case E_值类型::e_Type_LayoutList: {
			break;
		}
	}

	switch (操作类型) {
		case E_Prop_MapPtr_项事件类型::e_项删除: {
			ptrItem.m_PtrItem.erase(ptrItem.m_PtrItem.begin() + ptrItem.m_当前项);
			break;
		}

		case E_Prop_MapPtr_项事件类型::e_项添加: {
			S_MapPtrItem item;
			ptrItem.m_PtrItem.push_back(item);
			break;
		}

		case E_Prop_MapPtr_项事件类型::e_项名称改变: {
			break;
		}
		default: {
			uint32 offset = 操作类型;
			S_MapPtrItem& item = ptrItem.m_PtrItem[offset];


			C_编辑列表* editlist = static_cast<C_编辑列表*>(prop.m_UI->m_部件);
			int32 当前选项 = f_ui_列表框_取当前选中ID(editlist->m_ListBox);
			
			S_列表填充数据 填充项;

			switch (editlist->m_Value.m_Type) {
				case E_值类型::e_Type_SocketContainer: {

					uint32 插座索引 = 当前选项 + 1;
					
					E_插座方向 插座方向;
					if (editlist->m_Value.m_Name == DEF_输出插座标题) {
						插座方向 = E_插座方向::e_插座Type_输出;
					}
					else {
						插座方向 = E_插座方向::e_插座Type_输入;
					}

					auto& nodes = f_global_get激活节点();
					for (auto& node : nodes) {
						if (插座索引 < node->f_可添加删除插座起始位置(插座方向)) return;

						E_值类型 插座类型 = S_节点数据::g_值类型名称映射[item.m_Str];

						switch (node->m_Type) {
							case E_节点类型::e_节点Type_网格属性: {
								auto* socket = node->f_get输出插座(插座索引);
								S_网格自定义属性& 属性 = DEF_网格自定义属性插座数据(socket);
								属性.m_Type = 插座类型;
								break;
							}
							default: {
								C_插座基类* socket = f_su_切换后端插座类型(node, 插座方向, 插座索引, 插座类型);

								E_插座方向 颠倒插座方向;
								if (插座方向 == E_插座方向::e_插座Type_输入) {
									for (auto& panel : node->m_包含在多个视口的UI部件) {
										static_cast<C_节点面板*>(panel)->f_getInSocket()[插座索引]->m_SocketData = socket;
									}

									颠倒插座方向 = E_插座方向::e_插座Type_输出;
								}
								else {
									for (auto& panel : node->m_包含在多个视口的UI部件) {
										static_cast<C_节点面板*>(panel)->f_getOutSocket()[插座索引]->m_SocketData = socket;
									}

									颠倒插座方向 = E_插座方向::e_插座Type_输入;
								}


								C_节点树* tree = node->f_get父节点树();
								if (tree) {
									int32 父节点插座索引 = (插座索引 - node->f_get添加删除插座起始位置(false)) + node->f_get添加删除插座起始位置(true);
									//添加位置 = 要添加插座ID;
									//添加插座后位置 = 要添加插座ID + 1;

									for (auto& t : tree->m_节点树绑定的父节点) {
										auto* newSocket = f_su_切换后端插座类型(t, 颠倒插座方向, 父节点插座索引, 插座类型);

										if (颠倒插座方向 == E_插座方向::e_插座Type_输入) {
											for (auto& e : t->m_包含在多个视口的UI部件) {
												static_cast<C_节点面板*>(e)->f_getInSocket()[父节点插座索引]->m_SocketData = newSocket;
												e->m_更新绘制属性 = true;
											}
										}
										else {
											for (auto& e : t->m_包含在多个视口的UI部件) {
												static_cast<C_节点面板*>(e)->f_getOutSocket()[父节点插座索引]->m_SocketData = newSocket;
												e->m_更新绘制属性 = true;
											}
										}
									}
								}
								break;
							}
						}

						node->f_更新上层节点(true);


						if (插座方向 == E_插座方向::e_插座Type_输入) {
							填充项.m_item.push_back(node->f_get输入插座(插座索引)->m_identifier);
						}
						else {
							填充项.m_item.push_back(node->f_get输出插座(插座索引)->m_identifier);
						}
						
					}
					break;
				}

				case E_值类型::e_Type_ContainerBool:
				case E_值类型::e_Type_ContainerF32:
				case E_值类型::e_Type_ContainerI8:
				case E_值类型::e_Type_ContainerI32:
				case E_值类型::e_Type_ContainerUI32:
				case E_值类型::e_Type_ContainerVec2:
				case E_值类型::e_Type_ContainerVec3:
				case E_值类型::e_Type_ContainerVec4:
				case E_值类型::e_Type_ContaineriVec2:
				case E_值类型::e_Type_ContaineriVec3:
				case E_值类型::e_Type_ContaineriVec4:
				case E_值类型::e_Type_ContainerBound:
				case E_值类型::e_Type_ContainerValue: {
					auto& ContainerOut = f_prop_Container(editlist->m_Value);
					auto value_item = ContainerOut.m_Item[当前选项];
					填充项 = f_构建数值列表填充项(value_item, 当前选项);
					break;
				}
			}
			填充项.m_itemID.push_back(当前选项);
			f_ui_列表框_设置项(editlist->m_ListBox, 当前选项, 填充项);

			break;
		}
		
	}
	return;
}

Inline void f_属性容器添加项(C_编辑列表* box, S_Props& 容器, S_Props& 属性项, uint32 添加位置) {
	auto& ContainerOut = f_prop_Container(容器);
	ContainerOut.m_Item.insert(ContainerOut.m_Item.begin() + 添加位置, 属性项);

	S_列表填充数据 填充项 = f_构建数值列表填充项(属性项, 添加位置);
	填充项.m_itemID.push_back(-1);
	f_ui_列表框_添加列表项(box->m_ListBox, 填充项, 添加位置);

	switch (属性项.m_Type) {
		case E_值类型::e_Type_Vec2:
		case E_值类型::e_Type_Vec3:
		case E_值类型::e_Type_Vec4: {
			f_ui_绑定vec编辑框属性(box->mui_插座名称Vec编辑框, 属性项);
			break;
		}
		default:
			break;
	}
	
}
static E_事件是否传递 on_添加插座(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_编辑列表* box = static_cast<C_编辑列表*>(self->m_父部件);
	
	int32 添加位置 = f_ui_列表框_取当前选中ID(box->m_ListBox) + 1;
	

	switch (box->m_Value.m_Type) {
		case E_值类型::e_Type_SocketContainer:
		case E_值类型::e_Type_PropContainer: 
		case E_值类型::e_Type_LayoutList: {
		
			

			if (添加位置 < 0) 添加位置 = 0;
			//++添加位置;
			auto& nodes = f_global_get激活节点();
			for (auto& node : nodes) {
				E_插座方向 插座方向;
				if (box->m_Value.m_Name == DEF_输出插座标题) {
					插座方向 = E_插座方向::e_插座Type_输出;
				}
				else {
					插座方向 = E_插座方向::e_插座Type_输入;
				}
				E_值类型 默认类型;
				switch (node->m_Type) {
					case E_节点类型::e_节点Type_网格属性: {
						默认类型 = E_值类型::e_Type_网格自定义属性;
						break;
					}
					default:
						默认类型 = E_值类型::e_Type_I32;
						break;
				}
				auto* socket = f_su_创建节点后端插座(u"value" + f_整数值转宽字符串(添加位置, 2), 默认类型);




				int32 要添加插座ID;

				要添加插座ID = DEF_Max(node->f_可添加删除插座起始位置(插座方向), 添加位置);
				添加位置 = 要添加插座ID;
				uint32 添加插座后位置 = 要添加插座ID+1;
				node->f_add插座(socket, 插座方向, 添加插座后位置);

				E_插座方向 跌倒插座方向;
				if (插座方向 == E_插座方向::e_插座Type_输入) {
					for (auto& panel : node->m_包含在多个视口的UI部件) {
						static_cast<C_节点面板*>(panel)->f_addInSocket(socket, 添加插座后位置);
						panel->m_父部件->m_更新绘制属性 = true;
						f_NodePanel_更新布局(static_cast<C_节点面板*>(panel));
					}

					跌倒插座方向 = E_插座方向::e_插座Type_输出;
				}
				else {
					for (auto& panel : node->m_包含在多个视口的UI部件) {
						static_cast<C_节点面板*>(panel)->f_addOutSocket(socket, 添加插座后位置);
						panel->m_父部件->m_更新绘制属性 = true;
						f_NodePanel_更新布局(static_cast<C_节点面板*>(panel));
					}

					跌倒插座方向 = E_插座方向::e_插座Type_输入;
				}


				S_列表填充数据 item;
				item.m_item.push_back(socket->m_identifier);
				item.m_itemID.push_back(-1);
				f_ui_列表框_添加列表项(box->m_ListBox, item, 添加位置);




				C_节点树* tree = node->f_get父节点树();
				if (tree) {
					要添加插座ID = (添加位置 - node->f_get添加删除插座起始位置(false)) + node->f_get添加删除插座起始位置(true);
					//添加位置 = 要添加插座ID;
					添加插座后位置 = 要添加插座ID + 1;

					for (auto& t : tree->m_节点树绑定的父节点) {
						auto* newSocket = f_su_创建节点后端插座(socket->m_identifier, socket->m_Type);
						t->f_add插座(newSocket, 跌倒插座方向, 添加插座后位置);

						if (跌倒插座方向 == E_插座方向::e_插座Type_输入) {
							for (auto& e : t->m_包含在多个视口的UI部件) {
								static_cast<C_节点面板*>(e)->f_addInSocket(newSocket, 添加插座后位置);
							}
						}
						else {
							for (auto& e : t->m_包含在多个视口的UI部件) {
								static_cast<C_节点面板*>(e)->f_addOutSocket(newSocket, 添加插座后位置);
							}
						}
					}
				}
				


				
				break;
			}
			break;
		}

		case E_值类型::e_Type_Object_1D: {
			S_OBArray* obs = (S_OBArray*)f_prop_ArrayContainer(box->m_Value);
			uint32 num = S_框架::g_拾取物体.size();

			for (auto* ob : S_框架::g_拾取物体) {
				//S_物体* ob = S_节点数据::g_选中激活物体[i];
				bool 添加项 = true;
				for (uint32 j = 0; j < obs->count; ++j) {
					if (obs->ptr_userData[j] == ob) {
						添加项 = false;
						break;
					}
				}

				if (添加项) {
					S_列表填充数据 item;
					item.m_itemID.push_back(-1);
					item.m_Data = ob;
					item.m_item.push_back(ob->m_Name);

					f_core_array_push_back((S_Array*)obs, (uint8*)&ob);
					f_ui_列表框_添加列表项(box->m_ListBox, item, -1);
				}
			}
			break;
		}

		case E_值类型::e_Type_ContainerF32: {
			auto 属性项 = f_alloc_F32Prop(nullptr, u"F32");
			f_prop_F32(属性项) = 0;

			f_属性容器添加项(box, box->m_Value, 属性项, 添加位置);

			//auto& ContainerOut = f_prop_Container(box->m_Value);
			//ContainerOut.m_Item.insert(ContainerOut.m_Item.begin() + 添加位置, 属性项);
			//
			//S_列表填充数据 填充项 = f_构建数值列表填充项(属性项, 添加位置);
			//填充项.m_itemID.push_back(-1);
			//f_ui_列表框_添加列表项(box->m_ListBox, 填充项, 添加位置);
			break;
		}
		case E_值类型::e_Type_ContainerBool: {
			auto 属性项 = f_alloc_BoolProp(nullptr, u"Bool");
			f_prop_Bool(属性项) = true;
			f_属性容器添加项(box, box->m_Value, 属性项, 添加位置);
			break;
		}
		
		case E_值类型::e_Type_ContainerI8: {
			auto 属性项 = f_alloc_I8Prop(nullptr, u"I8");
			f_prop_I8(属性项) = 0;
			f_属性容器添加项(box, box->m_Value, 属性项, 添加位置);
			break;
		}
		case E_值类型::e_Type_ContainerI32: {
			auto 属性项 = f_alloc_I32Prop(nullptr, u"I32");
			f_属性容器添加项(box, box->m_Value, 属性项, 添加位置);
			break;
		}
		case E_值类型::e_Type_ContainerUI32: {
			auto 属性项 = f_alloc_UI32Prop(nullptr, u"UI32");
			f_属性容器添加项(box, box->m_Value, 属性项, 添加位置);
			break;
		}
		case E_值类型::e_Type_ContainerVec2: {
			auto 属性项 = f_alloc_Vec2Prop(nullptr, u"vec2");
			f_属性容器添加项(box, box->m_Value, 属性项, 添加位置);
			break;
		}
		case E_值类型::e_Type_ContainerVec3: {
			auto 属性项 = f_alloc_Vec3Prop(nullptr, u"vec3");
			f_属性容器添加项(box, box->m_Value, 属性项, 添加位置);
			break;
		}
		case E_值类型::e_Type_ContainerVec4: {
			auto 属性项 = f_alloc_Vec4Prop(nullptr, u"vec4");
			f_属性容器添加项(box, box->m_Value, 属性项, 添加位置);
			break;
		}
		case E_值类型::e_Type_ContaineriVec2:
		case E_值类型::e_Type_ContaineriVec3:
		case E_值类型::e_Type_ContaineriVec4:
		case E_值类型::e_Type_ContainerBound:
		case E_值类型::e_Type_ContainerValue: {
			
			break;
		}
	}
	return E_事件是否传递::e_事件传递_终止;
}

static E_事件是否传递 on_移除插座(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_编辑列表* box = static_cast<C_编辑列表*>(self->m_父部件);

	int32 列表项删除位置 = f_ui_列表框_取当前选中ID(box->m_ListBox);
	if(!f_ui_列表框_取项数量(box->m_ListBox)) return E_事件是否传递::e_事件传递_终止;
	
	bool 删除列表项 = true;
	switch (box->m_Value.m_Type) {
		case E_值类型::e_Type_SocketContainer:
		//case E_值类型::e_Type_PropContainer: 
		case E_值类型::e_Type_LayoutList: {
			E_插座方向 插座方向;
			if (box->m_Value.m_Name == DEF_输出插座标题) {
				插座方向 = E_插座方向::e_插座Type_输出;
			}
			else {
				插座方向 = E_插座方向::e_插座Type_输入;
			}

			int32 要删除插座 = 列表项删除位置 + 1;
			//++删除位置;
			auto& nodes = f_global_get激活节点();
			for (auto& node : nodes) {
				if (要删除插座 < node->f_可添加删除插座起始位置(插座方向)) {
					列表项删除位置 = node->f_可添加删除插座起始位置(插座方向) - 1;
					删除列表项 = false;
					break;
				}
				要删除插座 = DEF_Max(node->f_可添加删除插座起始位置(插座方向), 要删除插座);
			

				node->f_del插座(要删除插座, 插座方向);

				E_插座方向 跌倒插座方向;
				if (插座方向 == E_插座方向::e_插座Type_输入) {
					for (auto& panel : node->m_包含在多个视口的UI部件) {
						static_cast<C_节点面板*>(panel)->f_removeInSocket(要删除插座);
					}

					跌倒插座方向 = E_插座方向::e_插座Type_输出;
				}
				else {
					for (auto& panel : node->m_包含在多个视口的UI部件) {
						static_cast<C_节点面板*>(panel)->f_removeOutSocket(要删除插座);
					}

					跌倒插座方向 = E_插座方向::e_插座Type_输入;
				}


				C_节点树* tree = node->f_get父节点树();
				if (tree) {
					for (auto& t : tree->m_节点树绑定的父节点) {
						要删除插座 = (要删除插座 - node->f_get添加删除插座起始位置(false)) + node->f_get添加删除插座起始位置(true);

						if (跌倒插座方向 == E_插座方向::e_插座Type_输入) {
							if (要删除插座 >= t->f_get输入插座数量()) continue;
						}
						else {
							if (要删除插座 >= t->f_get输出插座数量()) continue;
						}

						for (auto& 同级或其他视口节点面板组件 : t->m_包含在多个视口的UI部件) {
							if (跌倒插座方向 == E_插座方向::e_插座Type_输入) {
								static_cast<C_节点面板*>(同级或其他视口节点面板组件)->f_removeInSocket(要删除插座);
							}
							else {
								static_cast<C_节点面板*>(同级或其他视口节点面板组件)->f_removeOutSocket(要删除插座);
							}
						}

						t->f_del插座(要删除插座, 跌倒插座方向);
					}
				}
			}
			break;
		}
		case E_值类型::e_Type_Object_1D: {
			S_OBArray* obs = (S_OBArray*)f_prop_ArrayContainer(box->m_Value);
			f_core_array_erase((S_Array*)obs, 列表项删除位置);
			break;
		}


		case E_值类型::e_Type_ContainerBool:
		case E_值类型::e_Type_ContainerF32:
		case E_值类型::e_Type_ContainerI8:
		case E_值类型::e_Type_ContainerI32:
		case E_值类型::e_Type_ContainerUI32:
		case E_值类型::e_Type_ContainerVec2:
		case E_值类型::e_Type_ContainerVec3:
		case E_值类型::e_Type_ContainerVec4:
		case E_值类型::e_Type_ContaineriVec2:
		case E_值类型::e_Type_ContaineriVec3:
		case E_值类型::e_Type_ContaineriVec4:
		case E_值类型::e_Type_ContainerBound:
		case E_值类型::e_Type_ContainerValue: {
			auto& ContainerOut = f_prop_Container(box->m_Value);
			ContainerOut.m_Item.erase(ContainerOut.m_Item.begin() + 列表项删除位置);
			break;
		}
	}


	if (删除列表项) {
		int32 itemNum = f_ui_列表框_移除列表项(box->m_ListBox, 列表项删除位置);
	}
	return E_事件是否传递::e_事件传递_终止;
}


static bool on_插座类型列表项选中回调(C_Widget* self, const std::vector<std::u16string>& name) {
	C_编辑列表* box = static_cast<C_编辑列表*>(self->m_父部件);
	g当前操作列表 = box;
	auto 选中项 = f_ui_列表框_取当前选中ID(box->m_ListBox);

	
	S_列表填充数据 item = f_ui_列表框_取当前选中项(box->m_ListBox);
	if (item.m_item.size()) {
		f_ui_set行编辑框文本(box->mui_插座名称编辑框, name[0]);

		
		switch (box->m_Value.m_Type) {
			case E_值类型::e_Type_SocketContainer:{
				++选中项;
				auto& nodes = f_global_get激活节点();
				for (auto& node : nodes) {
					switch (node->m_Type) {
						case E_节点类型::e_节点Type_全局: {
							
							break;
						}
						case E_节点类型::e_节点Type_类成员: {

							break;
						}
						case E_节点类型::e_节点Type_网格属性: {
							S_网格自定义属性& 属性 = DEF_网格自定义属性插座数据(node->f_get输出插座(选中项));
							f_prop_enum(box->m_分布类型) = 属性.m_分布方式;
							选中项 = f_从类型取类型名称字符串(属性.m_Type);
							break;
						}
						default:
							if (box->m_Value.m_Name == DEF_输入插座标题) {
								选中项 = f_从类型取类型名称字符串(node->f_get输入插座(选中项)->m_Type);

							}
							else {
								auto socket = node->f_get输出插座(选中项);
								if(socket) 选中项 = f_从类型取类型名称字符串(node->f_get输出插座(选中项)->m_Type);
							}
							break;
					}
					break;
				}
				break;
			}

			case E_值类型::e_Type_ContainerBool:
			case E_值类型::e_Type_ContainerF32:
			case E_值类型::e_Type_ContainerI8:
			case E_值类型::e_Type_ContainerI32:
			case E_值类型::e_Type_ContainerUI32: {
				auto& ContainerOut = f_prop_Container(box->m_Value);
				选中项 = f_从类型取类型名称字符串(ContainerOut.m_Item[选中项].m_Type);
				break;
			}
			case E_值类型::e_Type_ContainerVec2:
			case E_值类型::e_Type_ContainerVec3:
			case E_值类型::e_Type_ContainerVec4:
			case E_值类型::e_Type_ContaineriVec2:
			case E_值类型::e_Type_ContaineriVec3:
			case E_值类型::e_Type_ContaineriVec4:
			case E_值类型::e_Type_ContainerValue: {
				auto& ContainerOut = f_prop_Container(box->m_Value);
				auto value_item = ContainerOut.m_Item[选中项];
				f_ui_绑定vec编辑框属性(box->mui_插座名称Vec编辑框, value_item);
				//auto& ContainerOut = f_prop_Container(box->m_Value);
				//ContainerOut.m_Item[选中项].m_Value;
				//选中项 = f_从类型取类型名称字符串(ContainerOut.m_Item[选中项].m_Type);
				value_item.m_UI->m_Update = on_列表项改变_PropUpdate;
				break;
			}
		}
	}
	
	f_ui_设置下拉列表项(box->mui_插座类型切换下拉列表, 选中项);
	return true;
}

static void on_插座名称编辑改变(C_Widget* self) {
	C_编辑列表* box = static_cast<C_编辑列表*>(self->m_父部件);
	int32 当前选项 = f_ui_列表框_取当前选中ID(box->m_ListBox);
	if (当前选项 >= 0) {
		std::u16string text = f_ui_取行编辑框文本(self);
		S_列表填充数据 item;

		switch (box->m_Value.m_Type) {
			case E_值类型::e_Type_SocketContainer: {
			
				auto& nodes = f_global_get激活节点();
				f_str_去除空白字符(text);

				for (auto& node : nodes) {
					
					E_插座方向 插座方向;
					if (box->m_Value.m_Name == DEF_输入插座标题) {
						//node->f_get输入插座(当前选项 + 1)->m_identifier = text;
						text = node->f_插座名称分配(text, 当前选项 + 1, E_插座方向::e_插座Type_输入);
						插座方向 = E_插座方向::e_插座Type_输出;
					}
					else {
						//node->f_get输出插座(当前选项 + 1)->m_identifier = text;
						text = node->f_插座名称分配(text, 当前选项 + 1, E_插座方向::e_插座Type_输出);
						插座方向 = E_插座方向::e_插座Type_输入;
					}

					C_节点树* tree = node->f_get父节点树();
					if (tree) {
						for (auto& 绑定的父节点 : tree->m_节点树绑定的父节点) {
							if (插座方向 == E_插座方向::e_插座Type_输入) {
								绑定的父节点->f_get输入插座(当前选项 + 1)->m_identifier = text;
								for (auto& e : 绑定的父节点->m_包含在多个视口的UI部件) {
									//static_cast<C_节点面板*>(e)->m_NodeData->f_get输入插座(当前选项 + 1)->m_identifier = text;
									static_cast<C_节点面板*>(e)->m_NodeData->f_插座名称分配(text, 当前选项 + 1, E_插座方向::e_插座Type_输入);
								}
							}
							else {
								绑定的父节点->f_get输出插座(当前选项 + 1)->m_identifier = text;
								for (auto& e : 绑定的父节点->m_包含在多个视口的UI部件) {
									//static_cast<C_节点面板*>(e)->m_NodeData->f_get输出插座(当前选项 + 1)->m_identifier = text;
									static_cast<C_节点面板*>(e)->m_NodeData->f_插座名称分配(text, 当前选项 + 1, E_插座方向::e_插座Type_输出);
								}
							}
						}
					}
					
					node->f_更新上层节点(true);
					break;
				}
				box->m_ListBox->m_更新绘制属性 = true;
			
				break;
			}

			case E_值类型::e_Type_ContainerBool:
			case E_值类型::e_Type_ContainerF32:
			case E_值类型::e_Type_ContainerI8:
			case E_值类型::e_Type_ContainerI32:
			case E_值类型::e_Type_ContainerUI32:
			case E_值类型::e_Type_ContainerVec2:
			case E_值类型::e_Type_ContainerVec3:
			case E_值类型::e_Type_ContainerVec4:
			case E_值类型::e_Type_ContaineriVec2:
			case E_值类型::e_Type_ContaineriVec3:
			case E_值类型::e_Type_ContaineriVec4:
			case E_值类型::e_Type_ContainerBound:
			case E_值类型::e_Type_ContainerValue: {
				auto& ContainerOut = f_prop_Container(box->m_Value);
				auto value_item = ContainerOut.m_Item[当前选项];

				f_prop_F32(value_item) = f_字符串转F32(text);

				auto& nodes = f_global_get激活节点();
				for (auto& node : nodes) {
					node->f_更新上层节点(true);
				}
				break;
			}
		}

		item.m_item.push_back(text);
		f_ui_列表框_设置项(box->m_ListBox, 当前选项, item);
	}
}

static E_事件是否传递 on_列表项上移(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_编辑列表* box = static_cast<C_编辑列表*>(self->m_父部件);

	int32 列表项位置 = f_ui_列表框_取当前选中ID(box->m_ListBox);
	if (!f_ui_列表框_取项数量(box->m_ListBox)) return E_事件是否传递::e_事件传递_终止;

	bool 删除列表项 = true;
	switch (box->m_Value.m_Type) {
		case E_值类型::e_Type_SocketContainer: {
			E_插座方向 插座方向;
			if (box->m_Value.m_Name == DEF_输出插座标题) {
				插座方向 = E_插座方向::e_插座Type_输出;
			}
			else {
				插座方向 = E_插座方向::e_插座Type_输入;
			}

			int32 移动插座位置 = 列表项位置 + 1;
			//++删除位置;
			auto& nodes = f_global_get激活节点();
			for (auto& node : nodes) {
				if (移动插座位置 < node->f_可添加删除插座起始位置(插座方向)) {
					删除列表项 = false;
					break;
				}
				移动插座位置 = DEF_Max(node->f_可添加删除插座起始位置(插座方向), 移动插座位置);

				f_su_交换插座位置(node, 移动插座位置, 移动插座位置-1, 插座方向);
			}
			break;
		}
	}
	return E_事件是否传递::e_事件传递_终止;
}

static E_事件是否传递 on_列表项下移(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_编辑列表* box = static_cast<C_编辑列表*>(self->m_父部件);

	int32 列表项位置 = f_ui_列表框_取当前选中ID(box->m_ListBox);
	if (!f_ui_列表框_取项数量(box->m_ListBox)) return E_事件是否传递::e_事件传递_终止;

	switch (box->m_Value.m_Type) {
		case E_值类型::e_Type_SocketContainer: {
			E_插座方向 插座方向;
			if (box->m_Value.m_Name == DEF_输出插座标题) {
				插座方向 = E_插座方向::e_插座Type_输出;
			}
			else {
				插座方向 = E_插座方向::e_插座Type_输入;
			}

			int32 移动插座位置 = 列表项位置 + 1;
			//++删除位置;
			auto& nodes = f_global_get激活节点();
			for (auto& node : nodes) {
				

			}
			break;
		}
	}
	return E_事件是否传递::e_事件传递_终止;
}

static void f_网格属性变量分布类型(S_Props& 属性) {
	C_编辑列表* box = static_cast<C_编辑列表*>(属性.m_UI->m_部件->m_父部件);
	int32 选中项 = f_ui_列表框_取当前选中ID(box->m_ListBox);

	auto& nodes = f_global_get激活节点();
	
	for (auto& node : nodes) {
		switch (node->m_Type) {
			case E_节点类型::e_节点Type_网格属性: {
				S_网格自定义属性& 自定义属性 = DEF_网格自定义属性插座数据(node->f_get输出插座(选中项 + 1));
				自定义属性.m_分布方式 = f_prop_enum(属性);
				break;
			}
		}
	}
}

C_编辑列表::C_编辑列表(S_UI渲染环境& ctx) : C_Widget(&ctx) {
	if (g插座类型.size() < 1) {
		for (auto& e : S_节点数据::g_值类型名称映射) {
			g插座类型.push_back({ nullptr, (e.first), u"" });
		}
	}

	mf_绘制 = on_画插座编辑列表;
	mf_变换 = on_插座编辑列表属性修改;
	mf_布局 = on_插座编辑列表布局;

	m_ListBox = f_ui_创建列表(ctx, E_列表显示模式::e_列表模式_垂直);
	f_ui_列表框_绑定项选中回调(f_ui_get滚动框视口(m_ListBox), on_插座类型列表项选中回调);
	mui_addButton = f_ui_创建按钮(&ctx);
	mui_remButton = f_ui_创建按钮(&ctx);
	mui_upButton = f_ui_创建按钮(&ctx);
	mui_downButton = f_ui_创建按钮(&ctx);
	
	mui_addButton->m_ICO = u"加";
	mui_remButton->m_ICO = u"减";
	mui_upButton->m_ICO = u"上";
	mui_downButton->m_ICO = u"下";
	

	mui_插座类型切换下拉列表 = f_ui_创建下拉列表(ctx, false);
	mui_插座类型切换下拉列表->mf_变换 = on_插座编辑列表变换修改;

	m_Prop_插座类型切换_下拉列表 = f_alloc_StrIndexProp(g插座类型, u"插座类型");
	m_Prop_插座类型切换_下拉列表.m_UI->m_部件 = this;
	auto& p = f_prop_MapPrt(m_Prop_插座类型切换_下拉列表);
	p.mf_元素变更 = on_插座切换类型_项改变;
	f_ui_绑定下拉列表属性(mui_插座类型切换下拉列表, m_Prop_插座类型切换_下拉列表);
	

	mui_插座名称编辑框 = f_ui_创建行文本编辑框(ctx);
	m_矢量默认值 = f_alloc_Vec3Prop(nullptr, u"缺损值");
	mui_插座名称Vec编辑框 = f_ui_创建vec编辑框(ctx);
	mui_插座名称Vec编辑框->f_bind属性(m_矢量默认值);
	
	m_分布类型 = f_alloc_EnumProp(nullptr, {
		{u"点", u""},
		{u"面", u""},
		}, u"分布类型");
	m_分布类型.m_私有 = true;
	m_分布类型.m_UI->m_Update = f_网格属性变量分布类型;

	mui_属性分布方式 = f_ui_创建枚举选择框(ctx, E_方向::e_横向);
	mui_属性分布方式->f_bind属性(m_分布类型);

	f_添加子组件(m_ListBox);
	f_添加子组件(mui_addButton);
	f_添加子组件(mui_remButton);
	f_添加子组件(mui_upButton);
	f_添加子组件(mui_downButton);
	f_添加子组件(mui_插座类型切换下拉列表);
	f_添加子组件(mui_插座名称编辑框);
	f_添加子组件(mui_属性分布方式);

	f_setSize({ 256,512 });

	m_颜色A = S_UI主题::uic_深灰;
	m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形;

	
}

C_编辑列表::~C_编辑列表() {
	f_prop_Release(m_Prop_插座类型切换_下拉列表);
	f_prop_Release(m_分布类型);
	f_prop_Release(m_矢量默认值);
	C_Widget::~C_Widget();
}

void C_编辑列表::f_设置编辑类型(E_编辑列表类型 编辑列表类型) {
	switch (编辑列表类型) {
		case e_F32列表:
			//break;
		case e_I8列表:
			//break;
		case e_I32列表:
			//break;
		case e_U32列表:
			//break;

		case e_插座列表:
		case e_标量列表:
			mui_addButton->mf_鼠标点击 = on_添加插座;
			mui_remButton->mf_鼠标点击 = on_移除插座;
			f_ui_bind编辑框完成回调(mui_插座名称编辑框, on_插座名称编辑改变);
			f_ui_替换子组件(this, 6, mui_插座名称编辑框);
			break;
		
		case E_编辑列表类型::e_矢量列表: {
			mui_addButton->mf_鼠标点击 = on_添加插座;
			mui_remButton->mf_鼠标点击 = on_移除插座;
			//f_ui_bind编辑框完成回调(mui_插座名称Vec编辑框, on_矢量编辑改变);
			f_ui_替换子组件(this, 6, mui_插座名称Vec编辑框);
			break;
		}
		default:
			break;
	}

	mui_upButton->mf_鼠标点击 = on_列表项上移;
	mui_downButton->mf_鼠标点击 = on_列表项下移;
}


C_编辑列表* f_创建插座编辑列表(S_UI渲染环境& ctx) {
	C_编辑列表* box = new C_编辑列表(ctx);
	return box;
}

C_编辑列表* f_创建数值数组编辑列表(S_UI渲染环境& ctx) {
	
	return nullptr;
}

void f_插座编辑列表绑定属性数据(C_Widget* self, S_Props& prop, E_编辑列表类型 编辑列表类型) {
	C_编辑列表* box = static_cast<C_编辑列表*>(self);
	g当前操作列表 = nullptr;
	box->m_Value = prop;

	f_ui_列表框_删除项(box->m_ListBox, -1);
	std::vector<S_列表填充数据> items;

	box->mui_插座名称编辑框->m_开启渲染 = true;
	box->mui_插座名称Vec编辑框->m_开启渲染 = false;

	switch (prop.m_Type) {
		case E_值类型::e_Type_SocketContainer:
		case E_值类型::e_Type_PropContainer:
		case E_值类型::e_Type_LayoutList: {
			bool isInSocket = true;
			if (box->m_Value.m_Name == DEF_输出插座标题) {
				isInSocket = false;
			}
		
			auto 选中项 = f_ui_列表框_取当前选中ID(box->m_ListBox);
			if(选中项 < 0) 选中项 = 0;

			C_插座基类* socket = nullptr;
			auto& nodes = f_global_get激活节点();
			for (auto& node : nodes) {
				
				if (isInSocket) {
					uint32 输入插座Num = node->f_get输入插座数量();
					for (uint32 i = 1; i < 输入插座Num; ++i) {
						auto socket = node->f_get输入插座(i);
						S_列表填充数据 item;
						item.m_item.push_back(socket->m_identifier);
						item.m_itemID.push_back(-1);
						items.push_back(item);
					}
					
					socket = node->f_get输入插座(选中项 + 1);
				}
				else {
					uint32 输出插座Num = node->f_get输出插座数量();
					for (uint32 i = 1; i < 输出插座Num; ++i) {
						auto socket = node->f_get输出插座(i);
						S_列表填充数据 item;
						item.m_item.push_back(socket->m_identifier);
						item.m_itemID.push_back(-1);
						items.push_back(item);
					}
					
					socket = node->f_get输出插座(选中项 + 1);
				}
			}

			if (socket) {
				选中项 = f_从类型取类型名称字符串(socket->m_Type);
			}


			f_ui_设置下拉列表项(box->mui_插座类型切换下拉列表, 选中项);
			box->mui_插座类型切换下拉列表->m_开启渲染 = true;
			break;
		}

		case E_值类型::e_Type_Object_1D: {
			S_OBArray* obs = (S_OBArray*)f_prop_ArrayContainer(prop);
			for (uint32 i = 0; i < obs->count; ++i) {
				S_列表填充数据 item;
				item.m_item.push_back(obs->ptr_userData[i]->m_Name);
				item.m_itemID.push_back(-1);
				items.push_back(item);
			}
			box->mui_插座类型切换下拉列表->m_开启渲染 = false;
			break;
		}

		case E_值类型::e_Type_ContainerBool:
		case E_值类型::e_Type_ContainerF32:
		case E_值类型::e_Type_ContainerI8:
		case E_值类型::e_Type_ContainerI32:
		case E_值类型::e_Type_ContainerUI32: {
			f_容器类别填充(box->m_ListBox, box->m_Value, items);
			//auto& ContainerOut = f_prop_Container(box->m_Value);
			//uint32 num = ContainerOut.m_Item.size();
			//for (uint32 i = 0; i < num; ++i) {
			//	auto value_item = ContainerOut.m_Item[i];
			//	S_列表填充数据 item = f_构建数值列表填充项(value_item, i);
			//	items.push_back(item);
			//}
			box->mui_插座名称编辑框->m_开启渲染 = true;
			box->mui_插座名称Vec编辑框->m_开启渲染 = false;
			box->mui_插座类型切换下拉列表->m_开启渲染 = false;
			break;
		}
		case E_值类型::e_Type_ContainerVec2:
		case E_值类型::e_Type_ContainerVec3:
		case E_值类型::e_Type_ContainerVec4: 
		case E_值类型::e_Type_ContaineriVec2:
		case E_值类型::e_Type_ContaineriVec3:
		case E_值类型::e_Type_ContaineriVec4:
		case E_值类型::e_Type_ContainerValue: {
			f_容器类别填充(box->m_ListBox, box->m_Value, items);
			box->mui_插座名称编辑框->m_开启渲染 = false;
			box->mui_插座名称Vec编辑框->m_开启渲染 = true;
			box->mui_插座类型切换下拉列表->m_开启渲染 = false;

			//f_容器类别填充(box->m_Value, items);
			//auto& ContainerOut = f_prop_Container(box->m_Value);
			//uint32 num = ContainerOut.m_Item.size();
			//for (uint32 i = 0; i < num; ++i) {
			//	auto value_item = ContainerOut.m_Item[i];
			//	S_列表填充数据 item = f_构建数值列表填充项(value_item, i);
			//	items.push_back(item);
			//}
			//box->mui_插座类型切换下拉列表->m_开启渲染 = false;
			break;
		}
		default:
			break;
	}
	f_ui_列表框_填充(box->m_ListBox, items);

	
	box->f_设置编辑类型(编辑列表类型);
}


